package com.yyw.gulimall.order.service.impl;

import com.rabbitmq.client.Channel;
import com.yyw.gulimall.order.entity.OrderEntity;
import com.yyw.gulimall.order.entity.OrderReturnReasonEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yyw.common.utils.PageUtils;
import com.yyw.common.utils.Query;

import com.yyw.gulimall.order.dao.OrderItemDao;
import com.yyw.gulimall.order.entity.OrderItemEntity;
import com.yyw.gulimall.order.service.OrderItemService;


@Service("orderItemService")
@Slf4j
@RabbitListener(queues = "java.queue")
public class OrderItemServiceImpl extends ServiceImpl<OrderItemDao, OrderItemEntity> implements OrderItemService {

    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<OrderItemEntity> page = this.page(
                new Query<OrderItemEntity>().getPage(params),
                new QueryWrapper<OrderItemEntity>()
        );

        return new PageUtils(page);
    }

    /**
     * 测试接收消息
     * 使用 @RabbitListener(queues = "java.queue")
     */
    /*@RabbitListener(queues = "java.queue")
    public void accept(Message message, OrderReturnReasonEntity orderEntity) {
        log.info("接收到了消息:{}", message);
        log.info("消息主题: {}", orderEntity);
        log.info("\n");
    }*/


    /**
     * 使用  RabbitHandler 实现 接收同一个队列，不同的实体类
     * @param message
     * @param orderEntity
     */
    @RabbitHandler
    public void accept(Message message, OrderEntity orderEntity) {
        // log.info("接收到了消息:{}", message);
        log.info("消息主题: {}", orderEntity);
        log.info("\n");
    }

    @RabbitHandler
    public void accept(Message message, OrderReturnReasonEntity orderEntity, Channel channel) {
        // log.info("接收到了消息:{}", message);
        // 获取消息的唯一标签, 该标签是自增的
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            if (deliveryTag % 2 == 0 ) {
                // 签收消息  1. 传入消息的标签  2. 是否批量签收（选择就会把信道里的所有消息都给签收了）
                channel.basicAck(deliveryTag, false);
                log.info("我被签收了,{}", orderEntity);
            }else {
                // 效果和basicNack一样，不过没有批量的功能  传入1.消息的标签  2. 是否丢弃该消息
                // channel.basicReject(deliveryTag, true);
                // 拒收  1. 传入消息的标签   2. 是否批量拒收（true会把信道里的所有消息都给拒收）     3.是否丢弃该消息（true就会重新入队，false就会丢弃）
                // 如果第三个参数选择了true，那么该消息会重新入队，最终还会被执行该方法，被消费
                channel.basicNack(deliveryTag, false, true);
                log.warn("我被拒收了，不过我又入队了，我还会回来的, {}", orderEntity);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        log.info("消息主题: {}", orderEntity);
        log.info("\n");
    }



}